module klang.klang.常量值.Klang常量值_;
import 全局;
import ··类型_ = klang.编译.类型.类型_;
import klang.编译.核心.核心_: 整数_, 创建数组, 词典_, 创建词典从关联数组, 简单链表_;
import klang.编译.类型.类型_: 符号表_;
import klang.klang.类型.klang类型_: KSK, 运算符信息_, Klang签名_, Klang类型_, Klang符号_;
import klang.编译.类型.枚举值.枚举值_: SK;
import klang.编译.工具.工具_: 创建符号表;
符号表_ 空符号表;
Object[] 空数组;
词典_!(运算符信息_) 空运算符信息;
Klang签名_[] 空签名数组;
Klang类型_[] 空类型数组;
Klang符号_[] 空符号数组;
//#范围 内部变量
KSK[dstring] _标点表;
KSK[dstring] _关键字表;
//#结束范围
KSK[dstring] _klang令牌文本表;
dstring[] 组合令牌文本;
词典_!(KSK) 关键字词典;
词典_!(KSK) 标点令牌表;
dstring[] 关键字文本数组;
dstring[] 关键字EN文本组;
static this() {
    空符号表 = 创建符号表();
    空数组 = 创建数组!(Object)();
    空运算符信息 = new 词典_!(运算符信息_)();
    空签名数组 = 创建数组!(Klang签名_)();
    空类型数组 = 创建数组!(Klang类型_)();
    空符号数组 = 创建数组!(Klang符号_)();
    _标点表 = [
        "{"d : KSK.左大括号,
        "}"d : KSK.右大括号,
        "("d : KSK.左括号,
        ")"d : KSK.右括号,
        "["d : KSK.左方括号,
        "]"d : KSK.右方括号,
        "\""d : KSK.双引号,
        "'"d : KSK.单引号,
        "."d : KSK.点号,
        ";"d : KSK.分号,
        ","d : KSK.逗号,
        "<"d : KSK.左尖括号,
        ">"d : KSK.右尖括号,
        "+"d : KSK.加号,
        "-"d : KSK.减号,
        "*"d : KSK.星号,
        "\\"d : KSK.反斜杠,
        "/"d : KSK.除号,
        "%"d : KSK.百分号,
        "&"d : KSK.且号,
        "|"d : KSK.或号,
        "^"d : KSK.异或号,
        "!"d : KSK.叹号,
        "~"d : KSK.波折号,
        "$"d : KSK.美元,
        "?"d : KSK.问号,
        ":"d : KSK.冒号,
        "@"d : KSK.艾特,
        "#"d : KSK.井号,
        "`"d : KSK.反引号,
        "="d : KSK.等号,
        ":="d : KSK.冒等号,
        "=>"d : KSK.等右尖号,
        "..."d : KSK.三点号,
        ".."d : KSK.二点号,
        ".["d : KSK.点左方括号,
        ".<"d : KSK.点左尖括号,
        ".("d : KSK.点左括号,
        "?."d : KSK.问点号,
        "<="d : KSK.左尖等号,
        ">="d : KSK.右尖等号,
        "=="d : KSK.等等号,
        "!="d : KSK.叹等号,
        "&&"d : KSK.且且号,
        "||"d : KSK.或或号,
        "++"d : KSK.加加号,
        "--"d : KSK.减减号,
        "<<"d : KSK.左左尖号,
        ">>"d : KSK.右右尖号,
        ">>>"d : KSK.右右右尖号,
        "+="d : KSK.加等号,
        "-="d : KSK.减等号,
        "*="d : KSK.星等号,
        "/="d : KSK.除等号,
        "%="d : KSK.余等号,
        "~="d : KSK.连接等号,
        "<<="d : KSK.左左尖等号,
        ">>="d : KSK.右右尖等号,
        ">>>="d : KSK.右右右尖等号,
        "&="d : KSK.且等号,
        "|="d : KSK.或等号,
        "^="d : KSK.异或等号,
        "C++"d : KSK.C加加_
    ];
    _关键字表 = [
        "跳出"d : KSK.跳出_,
        "断言"d : KSK.断言_,
        "构建"d : KSK.构建_,
        "释放"d : KSK.释放_,
        "常量"d : KSK.常量_,
        "恒定"d : KSK.恒定_,
        "只读"d : KSK.只读_,
        "共享"d : KSK.共享_,
        "静态"d : KSK.静态_,
        "引用"d : KSK.引用_,
        "局部"d : KSK.局部_,
        "固定"d : KSK.固定_,
        "公开"d : KSK.公开_,
        "私有"d : KSK.私有_,
        "保护"d : KSK.保护_,
        "重载"d : KSK.重载_,
        "外部"d : KSK.外部_,
        "导出"d : KSK.导出_,
        "声明"d : KSK.声明_,
        "纯净"d : KSK.纯净_,
        "安全"d : KSK.安全_,
        "信任"d : KSK.信任_,
        "系统"d : KSK.系统_,
        "无回收"d : KSK.无回收_,
        "不抛出"d : KSK.不抛出_,
        "C"d : KSK.C_,
        "D"d : KSK.D_,
        "Windows"d : KSK.Windows_,
        "System"d : KSK.System_,
        "Objective_C"d : KSK.Objective_C_,
        "返回局部引用"d : KSK.返回局部引用_,
        "返回引用"d : KSK.返回引用_,
        "局部引用"d : KSK.局部引用_,
        "返回局部"d : KSK.返回局部_,
        "返回"d : KSK.返回_,
        "异步"d : KSK.异步_,
        "等待"d : KSK.等待_,
        "继续"d : KSK.继续_,
        "调试"d : KSK.调试_,
        "默认"d : KSK.默认_,
        "删除"d : KSK.删除_,
        "否则"d : KSK.否则_,
        "枚举"d : KSK.枚举_,
        "假"d : KSK.假_,
        "循环"d : KSK.循环_,
        "函数"d : KSK.函数_,
        "如果"d : KSK.如果_,
        "导入"d : KSK.导入_,
        "新建"d : KSK.新建_,
        "若是"d : KSK.若是_,
        "抛出"d : KSK.抛出_,
        "尝试"d : KSK.尝试_,
        "捕获"d : KSK.捕获_,
        "最后"d : KSK.最后_,
        "全局"d : KSK.全局_,
        "事件"d : KSK.事件_,
        "对象"d : KSK.对象_,
        "结构"d : KSK.结构_,
        "别名"d : KSK.别名_,
        "延迟"d : KSK.延迟_,
        "另如"d : KSK.另如_,
        "程序"d : KSK.程序_,
        "启动"d : KSK.启动_,
        "初始"d : KSK.初始_,
        "整数"d : KSK.整数_,
        "正整数"d : KSK.正整数_,
        "小数"d : KSK.小数_,
        "虚数"d : KSK.虚数_,
        "复数"d : KSK.复数_,
        "正量"d : KSK.正量_,
        "指针"d : KSK.指针_,
        "原型"d : KSK.原型_,
        "未知"d : KSK.未知_,
        "零值"d : KSK.零值_,
        "空址"d : KSK.空址_,
        "空值"d : KSK.空值_,
        "假如"d : KSK.假如_,
        "本体"d : KSK.本体_,
        "基类"d : KSK.基类_,
        "真"d : KSK.真_,
        "不及"d : KSK.不及_,
        "无值"d : KSK.无值_,
        "接口"d : KSK.接口_,
        "通用"d : KSK.通用_,
        "变量"d : KSK.变量_,
        "真假"d : KSK.真假_,
        "文本"d : KSK.文本_,
        "文本8"d : KSK.文本8_,
        "文本16"d : KSK.文本16_,
        "文本32"d : KSK.文本32_,
        "类型"d : KSK.类型_,
        "指令"d : KSK.指令_,
        "汇编"d : KSK.汇编_,
        "测试"d : KSK.测试_,
        "同步"d : KSK.同步_,
        "版本"d : KSK.版本_,
        "整数8"d : KSK.整数8_,
        "整数16"d : KSK.整数16_,
        "整数32"d : KSK.整数32_,
        "整数64"d : KSK.整数64_,
        "正整数8"d : KSK.正整数8_,
        "正整数16"d : KSK.正整数16_,
        "正整数32"d : KSK.正整数32_,
        "正整数64"d : KSK.正整数64_,
        "小数32"d : KSK.小数32_,
        "小数64"d : KSK.小数64_,
        "虚数32"d : KSK.虚数32_,
        "虚数64"d : KSK.虚数64_,
        "复数64"d : KSK.复数64_,
        "复数128"d : KSK.复数128_,
        "字符"d : KSK.字符_,
        "字符8"d : KSK.字符8_,
        "字符16"d : KSK.字符16_,
        "字符32"d : KSK.字符32_,
        "字节"d : KSK.字节_,
        "属于"d : KSK.属于_
    ];
    _klang令牌文本表 = ··spread!(KSK, dstring)(cast()(._标点表), cast()(._关键字表));
    组合令牌文本 = ["&&"d, "||"d, "++"d, "--"d, "=>"d, "=="d, ":="d, "!="d, "+="d, "-="d, "*="d, "/="d, "%="d, "~="d,
        "&="d, "|="d, "^="d, "..."d, ".."d, ".["d, ".<"d, ".("d, "?."d, "<<="d, "<="d, "<<"d, ">>>="d, ">>>"d, ">>="d, ">>"d, ">="d];
    关键字词典 = .创建关键字词典(._关键字表);
    标点令牌表 = .创建关键字词典(._标点表);
    关键字文本数组 = .制作关键字文本数组(._klang令牌文本表);
    关键字EN文本组 = .制作En数组();
}
enum 配置种类_ : int {
    Klang = 1,
    KlangModConfig = 2
}
词典_!(KSK) 创建关键字词典(KSK[dstring] 表) {
    return 创建词典从关联数组!(KSK)(表);
}
KSK 标识符转KSK(dstring id, KSK ksk) {
    if (关键字词典.具有(id)) {
        return 关键字词典.获取(id);
    }
    return ksk;
}
KSK 获取组合标点令牌(dstring id) {
    if (标点令牌表.具有(id)) {
        return 标点令牌表.获取(id);
    }
    return KSK.未知__;
}
dstring[] 制作关键字文本数组(KSK[dstring] 表) {
    dstring[] 结果 = 创建数组!(dstring)();
    结果.length = KSK.限定名;
    foreach (dstring v, KSK i; 表) {
        结果[(cast(size_t)(i))] = v;
    }
    return 结果;
}
dstring 获取KSK关键字文本(long ksk) {
    if (ksk >= KSK.左大括号 && ksk < KSK.标识符 || ksk > KSK.标识符 && ksk <= KSK.类型_) {
        return 关键字文本数组[(cast(size_t)(ksk))];
    }
    return ··null!(dstring);
}
dstring[] 制作En数组() {
    dstring[] ENs = 创建数组!(dstring)();
    ENs.length = KSK.限定名;
    ENs[KSK.整数8_] = "byte"d;
    ENs[KSK.整数16_] = "short"d;
    ENs[KSK.整数_] = "int"d;
    ENs[KSK.整数32_] = "int"d;
    ENs[KSK.整数64_] = "long"d;
    ENs[KSK.正整数8_] = "ubyte"d;
    ENs[KSK.正整数16_] = "ushort"d;
    ENs[KSK.正整数_] = "uint"d;
    ENs[KSK.正整数32_] = "uint"d;
    ENs[KSK.正整数64_] = "ulong"d;
    ENs[KSK.小数32_] = "float"d;
    ENs[KSK.小数64_] = "double"d;
    ENs[KSK.小数_] = "double"d;
    ENs[KSK.虚数32_] = "ifloat"d;
    ENs[KSK.虚数64_] = "idouble"d;
    ENs[KSK.复数64_] = "cfloat"d;
    ENs[KSK.复数128_] = "cdouble"d;
    ENs[KSK.字符_] = "dchar"d;
    ENs[KSK.字符8_] = "char"d;
    ENs[KSK.字符16_] = "wchar"d;
    ENs[KSK.字符32_] = "dchar"d;
    ENs[KSK.字节_] = "byte"d;
    ENs[KSK.只读_] = "const"d;
    ENs[KSK.恒定_] = "immutable"d;
    ENs[KSK.共享_] = "shared"d;
    ENs[KSK.无值_] = "void"d;
    ENs[KSK.文本_] = "dstring"d;
    ENs[KSK.文本8_] = "string"d;
    ENs[KSK.文本16_] = "wstring"d;
    ENs[KSK.文本32_] = "dstring"d;
    ENs[KSK.真假_] = "bool"d;
    ENs[KSK.通用_] = "any"d;
    ENs[KSK.空值_] = "null"d;
    ENs[KSK.空址_] = "null"d;
    ENs[KSK.零值_] = "null"d;
    ENs[KSK.正量_] = "size_t"d;
    ENs[KSK.指针_] = "ptrdiff_t"d;
    return ENs;
}
dstring 获取KSK关键字En文本(long ksk) {
    if (ksk >= KSK.左大括号 && ksk < KSK.标识符 || ksk > KSK.标识符 && ksk <= KSK.类型_) {
        return 关键字EN文本组[(cast(size_t)(ksk))];
    }
    return ··null!(dstring);
}
KSK 转换SK为KSK(SK sk) {
    switch (sk) {
        case SK.未知__: {
            return KSK.未知__;
        }
        case SK.文件结尾: {
            return KSK.文件结尾;
        }
        case SK.单行注释: {
            return KSK.单行注释;
        }
        case SK.多行注释: {
            return KSK.多行注释;
        }
        case SK.新行: {
            return KSK.新行;
        }
        case SK.空白: {
            return KSK.空白;
        }
        case SK.指令注释: {
            return KSK.指令注释;
        }
        case SK.冲突标记: {
            return KSK.冲突标记;
        }
        case SK.数字字面量: {
            return KSK.数字字面量;
        }
        case SK.文本字面量: {
            return KSK.文本字面量;
        }
        case SK.左大括号: {
            return KSK.左大括号;
        }
        case SK.右大括号: {
            return KSK.右大括号;
        }
        case SK.左括号: {
            return KSK.左括号;
        }
        case SK.右括号: {
            return KSK.右括号;
        }
        case SK.左方括号: {
            return KSK.左方括号;
        }
        case SK.右方括号: {
            return KSK.右方括号;
        }
        case SK.双引号: {
            return KSK.双引号;
        }
        case SK.单引号: {
            return KSK.单引号;
        }
        case SK.点号: {
            return KSK.点号;
        }
        case SK.分号: {
            return KSK.分号;
        }
        case SK.逗号: {
            return KSK.逗号;
        }
        case SK.左尖括号: {
            return KSK.左尖括号;
        }
        case SK.右尖括号: {
            return KSK.右尖括号;
        }
        case SK.加号: {
            return KSK.加号;
        }
        case SK.减号: {
            return KSK.减号;
        }
        case SK.星号: {
            return KSK.星号;
        }
        case SK.反斜杠: {
            return KSK.反斜杠;
        }
        case SK.除号: {
            return KSK.除号;
        }
        case SK.百分号: {
            return KSK.百分号;
        }
        case SK.且号: {
            return KSK.且号;
        }
        case SK.或号: {
            return KSK.或号;
        }
        case SK.异或号: {
            return KSK.异或号;
        }
        case SK.叹号: {
            return KSK.叹号;
        }
        case SK.波折号: {
            return KSK.波折号;
        }
        case SK.美元: {
            return KSK.美元;
        }
        case SK.问号: {
            return KSK.问号;
        }
        case SK.冒号: {
            return KSK.冒号;
        }
        case SK.艾特: {
            return KSK.艾特;
        }
        case SK.井号: {
            return KSK.井号;
        }
        case SK.反引号: {
            return KSK.反引号;
        }
        case SK.等号: {
            return KSK.等号;
        }
        case SK.标识符: {
            return KSK.标识符;
        }
        case SK.源文件: {
            return KSK.源文件;
        }
        default: {
            return KSK.保留不使用目标;
        }
    }
}
KSK SKs转为KSK(SK[] sks) {
    switch (sks.length) {
        case 1: {
            return .转换SK为KSK(sks[0]);
        }
        case 2: {
            SK sk_0 = sks[0];
            SK sk_1 = sks[1];
            if (sk_1 == SK.等号) {
                switch (sk_0) {
                    case SK.加号: {
                        return KSK.加等号;
                    }
                    case SK.减号: {
                        return KSK.减等号;
                    }
                    case SK.星号: {
                        return KSK.星等号;
                    }
                    case SK.除号: {
                        return KSK.除等号;
                    }
                    case SK.百分号: {
                        return KSK.余等号;
                    }
                    case SK.波折号: {
                        return KSK.连接等号;
                    }
                    case SK.且号: {
                        return KSK.且等号;
                    }
                    case SK.或号: {
                        return KSK.或等号;
                    }
                    case SK.异或号: {
                        return KSK.异或等号;
                    }
                    case SK.左尖括号: {
                        return KSK.左尖等号;
                    }
                    case SK.右尖括号: {
                        return KSK.右尖等号;
                    }
                    case SK.等号: {
                        return KSK.等等号;
                    }
                    case SK.叹号: {
                        return KSK.叹等号;
                    }
                    default: {
                        return KSK.未知__;
                    }
                }
            }
            else {
                switch (sk_0) {
                    case SK.点号: {
                        switch (sk_1) {
                            case SK.点号: {
                                return KSK.二点号;
                            }
                            case SK.左括号: {
                                return KSK.点左括号;
                            }
                            case SK.左方括号: {
                                return KSK.点左方括号;
                            }
                            case SK.左尖括号: {
                                return KSK.点左尖括号;
                            }
                            default: {
                                return KSK.未知__;
                            }
                        }
                    }
                    case SK.问号: {
                        if (sk_1 == SK.点号) {
                            return KSK.问点号;
                        }
                    }
                    case SK.且号: {
                        if (sk_1 == SK.且号) {
                            return KSK.且且号;
                        }
                    }
                    case SK.或号: {
                        if (sk_1 == SK.或号) {
                            return KSK.或或号;
                        }
                    }
                    case SK.加号: {
                        if (sk_1 == SK.加号) {
                            return KSK.加加号;
                        }
                    }
                    case SK.减号: {
                        if (sk_1 == SK.减号) {
                            return KSK.减减号;
                        }
                    }
                    case SK.左尖括号: {
                        if (sk_1 == SK.左尖括号) {
                            return KSK.左左尖号;
                        }
                    }
                    case SK.右尖括号: {
                        if (sk_1 == SK.右尖括号) {
                            return KSK.右右尖号;
                        }
                    }
                    default: {
                        return KSK.未知__;
                    }
                }
            }
        }
        case 3: {
            SK sk_0 = sks[0];
            SK sk_1 = sks[1];
            SK sk_2 = sks[2];
            if (sk_1 == SK.加号 && sk_2 == SK.加号 && sk_0 == SK.标识符) {
                // 这个有不确定性 要在外面重新确认;
                return KSK.C加加_;
            }
            if (sk_2 == SK.点号) {
                if (sk_0 == SK.点号 && sk_1 == SK.点号) {
                    return KSK.三点号;
                }
            }
            else if (sk_2 == SK.等号) {
                if (sk_0 == SK.左尖括号 && sk_1 == SK.左尖括号) {
                    return KSK.左左尖等号;
                }
                else if (sk_0 == SK.右尖括号 && sk_1 == SK.右尖括号) {
                    return KSK.右右尖等号;
                }
            }
            else if (sk_0 == SK.右尖括号 && sk_1 == SK.右尖括号 && sk_2 == SK.右尖括号) {
                return KSK.右右右尖号;
            }
            return KSK.未知__;
        }
        case 4: {
            if (sks[3] == SK.等号 && sks[0] == SK.右尖括号 && sks[1] == SK.右尖括号 && sks[2] == SK.右尖括号) {
                return KSK.右右右尖等号;
            }
        }
        default: break;
    }
    return KSK.未知__;
}
SK 转换KSK为SK(KSK ksk) {
    switch (ksk) {
        case KSK.未知__: {
            return SK.未知__;
        }
        case KSK.文件结尾: {
            return SK.文件结尾;
        }
        case KSK.单行注释: {
            return SK.单行注释;
        }
        case KSK.多行注释: {
            return SK.多行注释;
        }
        case KSK.新行: {
            return SK.新行;
        }
        case KSK.空白: {
            return SK.空白;
        }
        case KSK.指令注释: {
            return SK.指令注释;
        }
        case KSK.冲突标记: {
            return SK.冲突标记;
        }
        case KSK.数字字面量: {
            return SK.数字字面量;
        }
        case KSK.文本字面量: {
            return SK.文本字面量;
        }
        case KSK.左大括号: {
            return SK.左大括号;
        }
        case KSK.右大括号: {
            return SK.右大括号;
        }
        case KSK.左括号: {
            return SK.左括号;
        }
        case KSK.右括号: {
            return SK.右括号;
        }
        case KSK.左方括号: {
            return SK.左方括号;
        }
        case KSK.右方括号: {
            return SK.右方括号;
        }
        case KSK.双引号: {
            return SK.双引号;
        }
        case KSK.单引号: {
            return SK.单引号;
        }
        case KSK.点号: {
            return SK.点号;
        }
        case KSK.分号: {
            return SK.分号;
        }
        case KSK.逗号: {
            return SK.逗号;
        }
        case KSK.左尖括号: {
            return SK.左尖括号;
        }
        case KSK.右尖括号: {
            return SK.右尖括号;
        }
        case KSK.加号: {
            return SK.加号;
        }
        case KSK.减号: {
            return SK.减号;
        }
        case KSK.星号: {
            return SK.星号;
        }
        case KSK.反斜杠: {
            return SK.反斜杠;
        }
        case KSK.除号: {
            return SK.除号;
        }
        case KSK.百分号: {
            return SK.百分号;
        }
        case KSK.且号: {
            return SK.且号;
        }
        case KSK.或号: {
            return SK.或号;
        }
        case KSK.异或号: {
            return SK.异或号;
        }
        case KSK.叹号: {
            return SK.叹号;
        }
        case KSK.波折号: {
            return SK.波折号;
        }
        case KSK.美元: {
            return SK.美元;
        }
        case KSK.问号: {
            return SK.问号;
        }
        case KSK.冒号: {
            return SK.冒号;
        }
        case KSK.艾特: {
            return SK.艾特;
        }
        case KSK.井号: {
            return SK.井号;
        }
        case KSK.反引号: {
            return SK.反引号;
        }
        case KSK.等号: {
            return SK.等号;
        }
        case KSK.保留不使用标识符: {
            return SK.标识符;
        }
        case KSK.保留不使用目标: {
            return SK.目标;
        }
        case KSK.保留不使用源文件: {
            return SK.源文件;
        }
        default: {
            return SK.未知__;
        }
    }
}
SK[] KSK转为SKs(KSK ksk) {
    if (ksk <= KSK.保留不使用目标) {
        return [.转换KSK为SK(ksk)];
    }
    if (ksk >= KSK.标识符 && ksk <= KSK.属于_) {
        return [SK.标识符];
    }
    switch (ksk) {
        case KSK.冒等号: {
            return [SK.冒号, SK.等号];
        }
        case KSK.等右尖号: {
            return [SK.等号, SK.右尖括号];
        }
        case KSK.三点号: {
            return [SK.点号, SK.点号, SK.点号];
        }
        case KSK.二点号: {
            return [SK.点号, SK.点号];
        }
        case KSK.点左方括号: {
            return [SK.点号, SK.左方括号];
        }
        case KSK.点左尖括号: {
            return [SK.点号, SK.左尖括号];
        }
        case KSK.点左括号: {
            return [SK.点号, SK.左括号];
        }
        case KSK.问点号: {
            return [SK.点号, SK.问号];
        }
        case KSK.左尖等号: {
            return [SK.左尖括号, SK.等号];
        }
        case KSK.右尖等号: {
            return [SK.右尖括号, SK.等号];
        }
        case KSK.等等号: {
            return [SK.等号, SK.等号];
        }
        case KSK.叹等号: {
            return [SK.叹号, SK.等号];
        }
        case KSK.且且号: {
            return [SK.且号, SK.且号];
        }
        case KSK.或或号: {
            return [SK.或号, SK.或号];
        }
        case KSK.加加号: {
            return [SK.加号, SK.加号];
        }
        case KSK.减减号: {
            return [SK.减号, SK.减号];
        }
        case KSK.左左尖号: {
            return [SK.左尖括号, SK.左尖括号];
        }
        case KSK.右右尖号: {
            return [SK.右尖括号, SK.右尖括号];
        }
        case KSK.右右右尖号: {
            return [SK.右尖括号, SK.右尖括号, SK.右尖括号];
        }
        case KSK.加等号: {
            return [SK.或号, SK.等号];
        }
        case KSK.减等号: {
            return [SK.减号, SK.等号];
        }
        case KSK.星等号: {
            return [SK.星号, SK.等号];
        }
        case KSK.除等号: {
            return [SK.除号, SK.等号];
        }
        case KSK.余等号: {
            return [SK.百分号, SK.等号];
        }
        case KSK.连接等号: {
            return [SK.波折号, SK.等号];
        }
        case KSK.左左尖等号: {
            return [SK.左尖括号, SK.左尖括号, SK.等号];
        }
        case KSK.右右尖等号: {
            return [SK.右尖括号, SK.右尖括号, SK.等号];
        }
        case KSK.右右右尖等号: {
            return [SK.右尖括号, SK.右尖括号, SK.右尖括号, SK.等号];
        }
        case KSK.且等号: {
            return [SK.且号, SK.等号];
        }
        case KSK.或等号: {
            return [SK.或号, SK.等号];
        }
        case KSK.异或等号: {
            return [SK.异或号, SK.等号];
        }
        case KSK.C加加_: {
            return [SK.标识符, SK.加号, SK.加号];
        }
        default: break;
    }
    return ··null!(SK[]);
}
//#范围 转换函数
dstring 转换系统设置(dstring str) {
    if (str == "ananas"d) {
        return "ananas"d;
    }
    else if (str == "cloudabi"d) {
        return "cloudabi"d;
    }
    else if (str == "darwin"d) {
        return "darwin"d;
    }
    else if (str == "dragonfly"d) {
        return "dragonfly"d;
    }
    else if (str == "freebsd"d) {
        return "freebsd"d;
    }
    else if (str == "fuchsia"d) {
        return "fuchsia"d;
    }
    else if (str == "ios"d) {
        return "ios"d;
    }
    else if (str == "kfreebsd"d) {
        return "kfreebsd"d;
    }
    else if (str == "linux"d) {
        return "linux"d;
    }
    else if (str == "lv2"d) {
        return "lv2"d;
    }
    else if (str == "macos"d) {
        return "macos"d;
    }
    else if (str == "netbsd"d) {
        return "netbsd"d;
    }
    else if (str == "openbsd"d) {
        return "openbsd"d;
    }
    else if (str == "solaris"d) {
        return "solaris"d;
    }
    else if (str == "windows"d) {
        return "windows"d;
    }
    else if (str == "zos"d) {
        return "zos"d;
    }
    else if (str == "haiku"d) {
        return "haiku"d;
    }
    else if (str == "minix"d) {
        return "minix"d;
    }
    else if (str == "rtems"d) {
        return "rtems"d;
    }
    else if (str == "nacl"d) {
        return "nacl"d;
    }
    else if (str == "aix"d) {
        return "aix"d;
    }
    else if (str == "cuda"d) {
        return "cuda"d;
    }
    else if (str == "nvcl"d) {
        return "nvcl"d;
    }
    else if (str == "amdhsa"d) {
        return "amdhsa"d;
    }
    else if (str == "ps4"d) {
        return "ps4"d;
    }
    else if (str == "elfiamcu"d) {
        return "elfiamcu"d;
    }
    else if (str == "tvos"d) {
        return "tvos"d;
    }
    else if (str == "watchos"d) {
        return "watchos"d;
    }
    else if (str == "mesa3d"d) {
        return "mesa3d"d;
    }
    else if (str == "contiki"d) {
        return "contiki"d;
    }
    else if (str == "amdpal"d) {
        return "amdpal"d;
    }
    else if (str == "hermit"d) {
        return "hermit"d;
    }
    else if (str == "hurd"d) {
        return "hurd"d;
    }
    else if (str == "wasi"d) {
        return "wasi"d;
    }
    else if (str == "emscripten"d) {
        return "emscripten"d;
    }
    else {
        return "win32"d;
    }
}
dstring 转换架构设置(dstring str) {
    if (str == "i386"d) {
        return "i386"d;
    }
    else if (str == "i486"d) {
        return "i486"d;
    }
    else if (str == "i586"d) {
        return "i586"d;
    }
    else if (str == "i686"d) {
        return "i686"d;
    }
    else if (str == "i786"d) {
        return "i786"d;
    }
    else if (str == "i886"d) {
        return "i886"d;
    }
    else if (str == "i986"d) {
        return "i986"d;
    }
    else if (str == "amd64"d) {
        return "amd64"d;
    }
    else if (str == "x86_64h"d) {
        return "x86_64h"d;
    }
    else if (str == "powerpc"d) {
        return "powerpc"d;
    }
    else if (str == "powerpcspe"d) {
        return "powerpcspe"d;
    }
    else if (str == "ppc"d) {
        return "ppc"d;
    }
    else if (str == "ppc32"d) {
        return "ppc32"d;
    }
    else if (str == "powerpcle"d) {
        return "powerpcle"d;
    }
    else if (str == "ppcle"d) {
        return "ppcle"d;
    }
    else if (str == "ppc32le"d) {
        return "ppc32le"d;
    }
    else if (str == "powerpc64"d) {
        return "powerpc64"d;
    }
    else if (str == "ppu"d) {
        return "ppu"d;
    }
    else if (str == "ppc64"d) {
        return "ppc64"d;
    }
    else if (str == "powerpc64le"d) {
        return "powerpc64le"d;
    }
    else if (str == "ppc64le"d) {
        return "ppc64le"d;
    }
    else if (str == "xscale"d) {
        return "xscale"d;
    }
    else if (str == "xscaleeb"d) {
        return "xscaleeb"d;
    }
    else if (str == "aarch64"d) {
        return "aarch64"d;
    }
    else if (str == "aarch64_be"d) {
        return "aarch64_be"d;
    }
    else if (str == "aarch64_32"d) {
        return "aarch64_32"d;
    }
    else if (str == "arc"d) {
        return "arc"d;
    }
    else if (str == "arm64"d) {
        return "arm64"d;
    }
    else if (str == "arm64_32"d) {
        return "arm64_32"d;
    }
    else if (str == "arm64e"d) {
        return "arm64e"d;
    }
    else if (str == "arm"d) {
        return "arm"d;
    }
    else if (str == "armeb"d) {
        return "armeb"d;
    }
    else if (str == "thumb"d) {
        return "thumb"d;
    }
    else if (str == "thumbeb"d) {
        return "thumbeb"d;
    }
    else if (str == "avr"d) {
        return "avr"d;
    }
    else if (str == "m68k"d) {
        return "m68k"d;
    }
    else if (str == "msp430"d) {
        return "msp430"d;
    }
    else if (str == "mips"d) {
        return "mips"d;
    }
    else if (str == "mipseb"d) {
        return "mipseb"d;
    }
    else if (str == "mipsallegrex"d) {
        return "mipsallegrex"d;
    }
    else if (str == "mipsisa32r6"d) {
        return "mipsisa32r6"d;
    }
    else if (str == "mipsr6"d) {
        return "mipsr6"d;
    }
    else if (str == "mipsel"d) {
        return "mipsel"d;
    }
    else if (str == "mipsallegrexel"d) {
        return "mipsallegrexel"d;
    }
    else if (str == "mipsisa32r6el"d) {
        return "mipsisa32r6el"d;
    }
    else if (str == "mipsr6el"d) {
        return "mipsr6el"d;
    }
    else if (str == "mips64"d) {
        return "mips64"d;
    }
    else if (str == "mips64eb"d) {
        return "mips64eb"d;
    }
    else if (str == "mipsn32"d) {
        return "mipsn32"d;
    }
    else if (str == "mipsisa64r6"d) {
        return "mipsisa64r6"d;
    }
    else if (str == "mips64r6"d) {
        return "mips64r6"d;
    }
    else if (str == "mipsn32r6"d) {
        return "mipsn32r6"d;
    }
    else if (str == "mips64el"d) {
        return "mips64el"d;
    }
    else if (str == "mipsn32el"d) {
        return "mipsn32el"d;
    }
    else if (str == "mipsisa64r6el"d) {
        return "mipsisa64r6el"d;
    }
    else if (str == "mips64r6el"d) {
        return "mips64r6el"d;
    }
    else if (str == "mipsn32r6el"d) {
        return "mipsn32r6el"d;
    }
    else if (str == "r600"d) {
        return "r600"d;
    }
    else if (str == "amdgcn"d) {
        return "amdgcn"d;
    }
    else if (str == "riscv32"d) {
        return "riscv32"d;
    }
    else if (str == "riscv64"d) {
        return "riscv64"d;
    }
    else if (str == "hexagon"d) {
        return "hexagon"d;
    }
    else if (str == "s390x"d) {
        return "s390x"d;
    }
    else if (str == "systemz"d) {
        return "systemz"d;
    }
    else if (str == "sparc"d) {
        return "sparc"d;
    }
    else if (str == "sparcel"d) {
        return "sparcel"d;
    }
    else if (str == "sparcv9"d) {
        return "sparcv9"d;
    }
    else if (str == "sparc64"d) {
        return "sparc64"d;
    }
    else if (str == "tce"d) {
        return "tce"d;
    }
    else if (str == "tcele"d) {
        return "tcele"d;
    }
    else if (str == "xcore"d) {
        return "xcore"d;
    }
    else if (str == "nvptx"d) {
        return "nvptx"d;
    }
    else if (str == "nvptx64"d) {
        return "nvptx64"d;
    }
    else if (str == "le32"d) {
        return "le32"d;
    }
    else if (str == "le64"d) {
        return "le64"d;
    }
    else if (str == "amdil"d) {
        return "amdil"d;
    }
    else if (str == "amdil64"d) {
        return "amdil64"d;
    }
    else if (str == "hsail"d) {
        return "hsail"d;
    }
    else if (str == "hsail64"d) {
        return "hsail64"d;
    }
    else if (str == "spir"d) {
        return "spir"d;
    }
    else if (str == "spir64"d) {
        return "spir64"d;
    }
    else if (str == "lanai"d) {
        return "lanai"d;
    }
    else if (str == "renderscript32"d) {
        return "renderscript32"d;
    }
    else if (str == "renderscript64"d) {
        return "renderscript64"d;
    }
    else if (str == "shave"d) {
        return "shave"d;
    }
    else if (str == "ve"d) {
        return "ve"d;
    }
    else if (str == "wasm32"d) {
        return "wasm32"d;
    }
    else if (str == "wasm64"d) {
        return "wasm64"d;
    }
    else if (str == "csky"d) {
        return "csky"d;
    }
    else if (str == "aarch32"d) {
        return "aarch32"d;
    }
    else if (str == "aarch32_eb"d) {
        return "aarch32_eb"d;
    }
    else if (str == "aarch64_eb"d) {
        return "aarch64_eb"d;
    }
    else if (str == "arm64eb"d) {
        return "arm64eb"d;
    }
    else if (str == "bpf"d) {
        return "bpf"d;
    }
    else if (str == "bpf_be"d) {
        return "bpf_be"d;
    }
    else if (str == "bpfeb"d) {
        return "bpfeb"d;
    }
    else if (str == "bpf_le"d) {
        return "bpf_le"d;
    }
    else if (str == "bpfel"d) {
        return "bpfel"d;
    }
    else if (str == "kalimba"d) {
        return "kalimba"d;
    }
    else if (str == "kalimba3"d) {
        return "kalimba3"d;
    }
    else if (str == "kalimba4"d) {
        return "kalimba4"d;
    }
    else if (str == "kalimba5"d) {
        return "kalimba5"d;
    }
    else if (str == "invalid"d) {
        return "invalid"d;
    }
    else if (str == "armv2"d) {
        return "armv2"d;
    }
    else if (str == "armv2a"d) {
        return "armv2a"d;
    }
    else if (str == "armv3"d) {
        return "armv3"d;
    }
    else if (str == "armv3m"d) {
        return "armv3m"d;
    }
    else if (str == "armv4"d) {
        return "armv4"d;
    }
    else if (str == "armv4t"d) {
        return "armv4t"d;
    }
    else if (str == "armv5t"d) {
        return "armv5t"d;
    }
    else if (str == "armv5te"d) {
        return "armv5te"d;
    }
    else if (str == "armv5tej"d) {
        return "armv5tej"d;
    }
    else if (str == "armv6"d) {
        return "armv6"d;
    }
    else if (str == "armv6k"d) {
        return "armv6k"d;
    }
    else if (str == "armv6t2"d) {
        return "armv6t2"d;
    }
    else if (str == "armv6kz"d) {
        return "armv6kz"d;
    }
    else if (str == "armv6-m"d) {
        return "armv6-m"d;
    }
    else if (str == "armv7-a"d) {
        return "armv7-a"d;
    }
    else if (str == "armv7ve"d) {
        return "armv7ve"d;
    }
    else if (str == "armv7-r"d) {
        return "armv7-r"d;
    }
    else if (str == "armv7-m"d) {
        return "armv7-m"d;
    }
    else if (str == "armv7e-m"d) {
        return "armv7e-m"d;
    }
    else if (str == "armv8-a"d) {
        return "armv8-a"d;
    }
    else if (str == "armv8.1-a"d) {
        return "armv8.1-a"d;
    }
    else if (str == "armv8.2-a"d) {
        return "armv8.2-a"d;
    }
    else if (str == "armv8.3-a"d) {
        return "armv8.3-a"d;
    }
    else if (str == "armv8.4-a"d) {
        return "armv8.4-a"d;
    }
    else if (str == "armv8.5-a"d) {
        return "armv8.5-a"d;
    }
    else if (str == "armv8.6-a"d) {
        return "armv8.6-a"d;
    }
    else if (str == "armv8.7-a"d) {
        return "armv8.7-a"d;
    }
    else if (str == "armv8-r"d) {
        return "armv8-r"d;
    }
    else if (str == "armv8-m.base"d) {
        return "armv8-m.base"d;
    }
    else if (str == "armv8-m.main"d) {
        return "armv8-m.main"d;
    }
    else if (str == "armv8.1-m.main"d) {
        return "armv8.1-m.main"d;
    }
    else if (str == "iwmmxt"d) {
        return "iwmmxt"d;
    }
    else if (str == "iwmmxt2"d) {
        return "iwmmxt2"d;
    }
    else if (str == "armv7s"d) {
        return "armv7s"d;
    }
    else if (str == "armv7k"d) {
        return "armv7k"d;
    }
    else {
        return "x86_64"d;
    }
}
dstring 转换环境设置(dstring str) {
    if (str == "eabihf"d) {
        return "eabihf"d;
    }
    else if (str == "eabi"d) {
        return "eabi"d;
    }
    else if (str == "gnuabin32"d) {
        return "gnuabin32"d;
    }
    else if (str == "gnuabi64"d) {
        return "gnuabi64"d;
    }
    else if (str == "gnueabihf"d) {
        return "gnueabihf"d;
    }
    else if (str == "gnueabi"d) {
        return "gnueabi"d;
    }
    else if (str == "gnux32"d) {
        return "gnux32"d;
    }
    else if (str == "gnu_ilp32"d) {
        return "gnu_ilp32"d;
    }
    else if (str == "code16"d) {
        return "code16"d;
    }
    else if (str == "gnu"d) {
        return "gnu"d;
    }
    else if (str == "android"d) {
        return "android"d;
    }
    else if (str == "musleabihf"d) {
        return "musleabihf"d;
    }
    else if (str == "musleabi"d) {
        return "musleabi"d;
    }
    else if (str == "muslx32"d) {
        return "muslx32"d;
    }
    else if (str == "musl"d) {
        return "musl"d;
    }
    else if (str == "itanium"d) {
        return "itanium"d;
    }
    else if (str == "cygnus"d) {
        return "cygnus"d;
    }
    else if (str == "coreclr"d) {
        return "coreclr"d;
    }
    else if (str == "simulator"d) {
        return "simulator"d;
    }
    else if (str == "macabi"d) {
        return "macabi"d;
    }
    else {
        return "msvc"d;
    }
}
dstring 转换支持设置(dstring str) {
    if (str == "apple"d) {
        return "apple"d;
    }
    else if (str == "scei"d) {
        return "scei"d;
    }
    else if (str == "sie"d) {
        return "sie"d;
    }
    else if (str == "fsl"d) {
        return "fsl"d;
    }
    else if (str == "ibm"d) {
        return "ibm"d;
    }
    else if (str == "img"d) {
        return "img"d;
    }
    else if (str == "mti"d) {
        return "mti"d;
    }
    else if (str == "nvidia"d) {
        return "nvidia"d;
    }
    else if (str == "csr"d) {
        return "csr"d;
    }
    else if (str == "myriad"d) {
        return "myriad"d;
    }
    else if (str == "amd"d) {
        return "amd"d;
    }
    else if (str == "mesa"d) {
        return "mesa"d;
    }
    else if (str == "suse"d) {
        return "suse"d;
    }
    else if (str == "oe"d) {
        return "oe"d;
    }
    else {
        return "pc"d;
    }
}
dstring 转换输出类型设置(dstring str) {
    if (str == "elf"d) {
        return "elf"d;
    }
    else if (str == "lib"d) {
        return "lib"d;
    }
    else if (str == "staticLib"d) {
        return "staticLib"d;
    }
    else if (str == "dynamicLib"d) {
        return "dynamicLib"d;
    }
    else {
        return "exe"d;
    }
}
dstring 转换平台设置(dstring str) {
    if (str == "xcoff"d) {
        return "xcoff"d;
    }
    else if (str == "elf"d) {
        return "elf"d;
    }
    else if (str == "goff"d) {
        return "goff"d;
    }
    else if (str == "macho"d) {
        return "macho"d;
    }
    else if (str == "wasm"d) {
        return "wasm"d;
    }
    else {
        return "coff"d;
    }
}
dstring 转换输出模式设置(dstring str) {
    if (str == "调试"d) {
        return "调试"d;
    }
    else if (str == "发布"d) {
        return "发布"d;
    }
    else {
        return "测试"d;
    }
}
